import { Method } from 'axios';
import moment from 'moment';
import { getTokenHsbankNo } from '@/utils/auth';

let RTNIND_value = ''; // 全局的翻页标志
let cardList: any[] = [];
/**
 * 判断目标是否为未定义或空类型
 * @param target 待判断目标
 * @returns {boolean} true：是；false：不是
 * @unit_test Common.spec.ts
 */
function isNull(target: any) {
    return target === undefined || target === null;
}

/**
 * 判断目标是否为布尔类型
 * @param target 待判断目标
 * @returns {boolean} true：是；false：不是
 * @unit_test Common.spec.ts
 */
function isBoolean(target: any) {
    return typeof target === 'boolean';
}

/**
 * 判断目标是否为字符串类型
 * @param target 待判断目标
 * @returns {boolean} true：是；false：不是
 * @unit_test Common.spec.ts
 */
function isString(target: any) {
    return typeof target === 'string';
}

/**
 * 判断目标是否为数字类型
 * @param target 待判断目标
 * @returns {boolean} true：是；false：不是
 * @unit_test Common.spec.ts
 */
function isNumber(target: any) {
    return typeof target === 'number';
}

/**
 * 判断目标是否为空，目标为空包括以下情况：
 * 目标类型为：undefined 或 null
 * @param target 待判断目标
 */
function isEmpty(target: any) {
    return !target;
}

function base64Encode(target: any) {
    const { Base64 } = require('js-base64');

    if (isEmpty(target)) {
        return '';
    }
    return Base64.encode(target);
}
/**
 * 手机号 展示加空格
 */
function MobileNum(obj: String) {
    let value = obj;
    value = value.replace(/\s*/g, '');
    const result = [];
    for (let i = 0; i < value.length; i++) {
        if (i == 3 || i == 7) {
            result.push(` ${value.charAt(i)}`);
        } else {
            result.push(value.charAt(i));
        }
    }
    obj = result.join('');
    return obj;
}

/**
 * 关闭页面 删除路由
 * view
 * that: 传入的vue实例 -> this
 * type: 类型 -> 1-关闭tabs页面 删除tabs路由  2-关闭系统菜单路由
 */
function closePage(view: any, that: any, type: number) {
    // 当被缓存的路由从缓存中移除时，需要调用此方法移除route对象中的cacheParams
    if (view.meta.cacheParams && Object.keys(view.meta.cacheParams).length > 0) {
        view.meta.cacheParams = null;
    }
    // 根据类型判断关闭路由 1-业务菜单路由，tabs路由模块 2-系统菜单路由，左侧菜单模块路由
    const targetCommit = type === 1 ? 'tagsView/delVisitedViewsItem' : 'tagsView/delVisitedViews';
    that.$store.dispatch(targetCommit, view).then((views: any) => {
        if (view.path === that.$route.path) {
            const latestView = views.slice(-1)[0];
            if (latestView) {
                that.$router.push(latestView);
            } else if (targetCommit === 'tagsView/delVisitedViews') {
                that.$router.push('/index/home');
            } else {
                that.$router.push('/businessSystem/defaultPageItem');
            }
        }
    });
}

/**
 *  处理字符串的前后空格
 * * */
function trimString(val: String) {
    return val.replace(/(^\s*)|(\s*$)/g, '');
}

/**
 *  字符串替换  str原字符串  index要修改的下标 target-要替换的值
 * * */
function reolaceString(str: String, index: any, target: any) {
    const newStr = `${str}`;
    const arr = newStr.split('');
    arr[index] = target;
    return arr.join('');
}

/**
 *  位数不足补0  str 输入字符串 num 补足后的字符串长度
 * * */
function strZeroFill(str: any, num: any) {
    const strLength = String(str).length;
    let newStr = str;
    if (strLength < num) {
        const strNewLength = num - strLength;
        for (let i = 0; i < strNewLength; i++) {
            newStr = `0${newStr}`;
        }
    }
    return newStr;
}

/**
*  格式化数字， 整数部分每隔3位添加 逗号
*  num 传入的需要格式化的数字 字符串
*  fix 保留小数位数
* * */
function formatNumber(num: String, fix: number) {
    const newNum = `${Number(num).toFixed(fix)}`; // 确保传入的是全数字的字符串
    const numArr = newNum.split('.');
    let str1 = numArr[0];
    const str2 = numArr.length > 1 ? (`.${numArr[1]}`) : '';
    const rgx = /(\d+)(\d{3})/;
    if (rgx.test(str1)) {
        str1 = str1.replace(rgx, '$1' + ',' + '$2');
    }
    if (num == '288447') {
    }
    return str1 + str2;
}

/**
*  数值格式化函数
*  Dight:要格式化的 数字
*  How::要保留的小数位数
* * */
function ForDight(Dight: number, How: number) {
    const res = Math.round(Dight * Math.pow(10, How)) / Math.pow(10, How);
    return res;
}

/**
*  数字转字符串，根据传入长度 补0
*  num: 传入的数值或字符串类型的数值
*  How::最终长度
* * */
function itoStr(num: any, length: number) {
    let newNum = (`${num}`).trim();
    if (newNum.length < length) {
        newNum = `00000000000000000000${newNum}`;
    }
    const res = newNum.substring(newNum.length - length);
    return res;
}

/**
*  根据传入的查询字段 --> 获取对应的字典值
*  cardList: 卡列表数据
*  cardNo: 卡号
*  target: 需要查询的目标字段
*  that: vue实例
* * */
async function getDictValue(cardList: any, cardNo: any, target: any, that: any) {
    let params = {};
    let result;
    cardList.forEach((item: any) => {
        if (item.CARDNBR === cardNo) {
            params = {
                detailCode: itoStr(item[target], 4),
                dictValue: target,
            };
        }
    });
    await that.$post.Dict.dataBaseDict(params).then((res: any) => {
        if (res.status === 200) {
            result = res.data.content;
        } else {
            result = '';
            that.$message.error(res.data.msg);
        }
    });
    return result;
}
/**
*  根据传入的查询字段 --> 获取对应的下拉对象 字典值
*  target: 需要查询的目标字段
*  that: vue实例
* * */
async function getDictSelectList(target: String, that: any) {
    // 数据字典接口
    const Params = {
        dictValue: target,
    };
    try {
        const res = await that.$post.common.getBaseDataList(Params);
        if (res.status === 200) {
            // console.log(res.data.content);
            return res.data.content || [];
        }
        that.$message.error(res.data.msg);
    } catch (error) {
        that.$message.error(error);
        return [];
    }
}

/**
*  根据传入的查询字段 --> 获取对应的值 字典值
*  target: 需要查询的目标字段
*  that: vue实例
* * */
async function getDictSelectListOneValue(target: String, that: any) {
    // 数据字典接口
    const Params = {
        dictValue: target,
    };
    try {
        const res = await that.$post.common.getBaseDataList(Params);
        if (res.status === 200) {
            // console.log('res.data.content', res.data.content);
            if (res.data.content.length === 1) {
                return res.data.content[0].code;
            }
            return res.data.content || [];
        }
        that.$message.error(res.data.msg);
    } catch (error) {
        that.$message.error(error);
        return [];
    }
}

/**
*  校验挽留规则
*  target: 查询参数
*  that: vue实例
* * */
async function checkUrgeRules(target: Object, that: any) {
    try {
        const res = await that.$post.queryServiceClass.checkUrgeRules(target);
        if (res.status === 200) {
            // console.log(res.data.content);
            return res.data.content || [];
        }
        that.$message.error(res.data.msg);
    } catch (error) {
        that.$message.error(error);
        return [];
    }
}

/**
*  校验不可销户规则
*  target: 查询参数
*  that: vue实例
* * */
async function checkApplyRules(target: Object, that: any) {
    try {
        const res = await that.$post.queryServiceClass.checkApplyRules(target);
        if (res.status === 200) {
            // console.log(res.data.content);
            return res.data.content || [];
        }
        that.$message.error(res.data.msg);
    } catch (error) {
        that.$message.error(error);
        return [];
    }
}

/**
*  根据传入的查询字段 --> 获取对应的下拉对象 字典值， 特殊： 会合并本银行和cupd的字典值
*  target: 需要查询的目标字段
*  that: vue实例
* * */
async function getALLCupdAndIBankDict(target: String, that: any) {
    // 数据字典接口
    const Params = {
        dictValue: target,
    };
    try {
        const res = await that.$post.common.getALLCupdDataList(Params);
        if (res.status === 200) {
            // console.log(res.data.content);
            return res.data.content || [];
        }
        that.$message.error(res.data.msg);
    } catch (error) {
        that.$message.error(error);
        return [];
    }
}

/**
*  根据传入的查询字段 和值--> 获取对应的字典值
*  target: 需要查询的目标字段
*  value: 字段对应的值
*  that: vue实例
* * */
async function getDictMappingValue(target: String, value: any, that: any) {
    let cateValues = (`${value}`).trim();
    // 判断一下是否是 账户类别字段
    if (target === 'CATE') {
        cateValues = cateValues;
    }
    //  判断是否是 卡产品字段 是的话需要补0 位数为4
    const strLength = cateValues.length;
    if (target === 'PRODUCT' && (strLength < 4)) {
        for (let i = 0; 4 - strLength > i; i++) {
            cateValues = `0${cateValues}`;
        }
    }
    // console.log(cateValues,"cateValues");

    const Params = {
        dictValue: target,
        detailCode: cateValues,
        pageNum: 1,
        pageSize: 1000,
    };
    try {
        const res = await that.$post.Dict.dataBaseDict(Params);
        if (res.status === 200) {
            return res.data.content;
        }
        that.$message.error(res.data.msg);
    } catch (error) {
        that.$message.error(error);
        return value;
    }
}

/**
*  获取分期期数 下拉选择列表数据
*  CREDNO: 信用计划编号
*  that: vue实例 this
* * */
async function getInstalmentList(CREDNO: any, that: any) {
    const resArr: any[] = []; // 处理完成后的数组
    await that.$post.common.getInstalmentNoList({ itemNo: CREDNO }).then((res: any) => {
        if (res.status === 200) {
            if (res.data.content.length) {
                const data = res.data.content[0]; // 接口获取的数据
                const appFeeratioList = data.appFeeratio.split(','); // 分期费率
                const fixfeeList = data.fixfee.split(','); // 申请手续费 固定费用
                const nbrMthsList = data.nbrMths.split(','); // 分期月份期数
                const paytypeList = data.paytype.split(','); // 手续费支付方式

                appFeeratioList.forEach((item: any, index: number) => {
                    resArr.push({
                        id: `${nbrMthsList[index] + item}`, // id
                        label: `${nbrMthsList[index]}期 -- ${item}`, // 下拉框展示文字
                        appFeeratio: item,
                        fixfee: fixfeeList[index],
                        nbrMths: nbrMthsList[index],
                        paytype: paytypeList[index],
                    });
                });
            }
        }
    });
    // console.log(resArr, 'resArr')
    return resArr;
}

/**
*  获取分期期数 直接返回所有元数据
*  CREDNO: 信用计划编号, 为空返回所有信息
*  that: vue实例 this
* * */
async function getAllInstalmentList(CREDNO: any, that: any) {
    let resArr: any = {}; // 处理完成后的数组
    await that.$post.common.getInstalmentNoList({ itemNo: CREDNO }).then((res: any) => {
        // if (res.status === 200) {
        // console.log(res);
        resArr = res;
        // console.log(resArr);
        return resArr;
        // if(res.data.content.length) {
        //     let data = res.data.content[0] // 接口获取的数据
        //     let appFeeratioList = data.appFeeratio.split(',') // 分期费率
        //     let fixfeeList = data.fixfee.split(',') // 申请手续费 固定费用
        //     let nbrMthsList = data.nbrMths.split(',') // 分期月份期数
        //     let paytypeList = data.paytype.split(',') // 手续费支付方式

        //     appFeeratioList.forEach( (item: any, index: number) => {
        //         resArr.push({
        //             id: nbrMthsList[index] + item + '', // id
        //             label: nbrMthsList[index] + '期 -- ' + item, // 下拉框展示文字
        //             appFeeratio: item,
        //             fixfee: fixfeeList[index],
        //             nbrMths: nbrMthsList[index],
        //             paytype: paytypeList[index]
        //         })
        //     })
        // }
        // }
        // return false
    });
    // console.log(resArr, 'resArr')
}


/**
*  获取账户类别 名称
*  cardList: 卡列表数据
*  cardInfo: 当前默认卡信息
*  that: vue实例
* * */
async function getAccountTypeName(cardList: any, cardInfo: any, that: any) {
    let params = {};
    let accountName;
    let CATE: any;
    cardList.forEach((item: any) => {
        if (item.CARDNBR === cardInfo.CARDNO) {
            CATE = (`${item.CATEGORY}`).trim();
            params = {
                // detailCode: CATE.substr(0, 1),
                detailCode: CATE,
                dictValue: 'CATE',
            };
        }
    });
    await that.$post.Dict.dataBaseDict(params).then((res: any) => {
        if (res.status === 200) {
            accountName = res.data.content || CATE;
        } else {
            that.$message.error(res.data.msg);
        }
    });
    return accountName;
}
/**
*  获取字典里 某一字段的多条数据
*  target: 字段
*  that: vue实例
* * */
// 查字典 多条数据
async function getDictDetailPage(target: any, that: any) {
    const params = {
        dictValue: target,
        pageNum: 1,
        pageSize: 1000,
    };
    // common.getBaseDataList
    let dataValue;
    await that.$post.dictDetail.getDictDetail(params).then((res: any) => {
        if (res.status === 200) {
            dataValue = res.data.content.dictDetailList;
        } else {
            that.$message.error(res.data.msg);
        }
    });
    return dataValue;
}

// 查字典 根据银行号 多条数据
async function getDictFromBankNum(target: string, that: any) {
    const params = {
        dictValue: target,
        lesseeCode: getTokenHsbankNo('HsbankNo'),
    };
    let dataValue: any[] = [];
    await that.$post.dictDetail.getAllDictDetail(params).then((res: any) => {
        if (res.status === 200) {
            dataValue = res.data.content;
        } else {
            that.$message.error(res.data.msg);
        }
    });
    return dataValue;
}

/**
*  处理动态短信内容
*  str: 传入的动态短信模板内容
*  that: vue实例
* * */
function dealTempContent(str: String, that: any) {
    const resArr: any[] = [];
    const strArr = str.split('<_');
    // console.log(strArr, 'strArr');

    strArr.forEach((item: any) => {
        if (item && item.indexOf('_>') !== -1) {
            // 将获取到的变量以点继续切割  -> 盒子啊一起的时候 that[变量.变量] 的形式 取不到值
            const valArr = item.split('_>')[0].split('.');
            // 取值
            let value = that[valArr[0]][valArr[1]] ? that[valArr[0]][valArr[1]] : '0.00';
            // console.log(value, 'value1');
            // 判断 该变量的值是否是字符串类型 是->去空格
            if (value && typeof (value) === 'string') {
                value = value.trim();
                // console.log(value, 'value');
            }
            item = value + item.split('_>')[1];
            // console.log(item, 'item');
        }
        resArr.push(item);
    });
    // console.log(strArr, 'strArr')
    // console.log(resArr,'resArr')
    // console.log(resArr, 'resArr');

    const res = resArr.join('');
    return res;
}

// 处理时间格式化
/**
 * 解决时间格式问题
 * @param myMoment(a) a为需要格式化的日期
 * @param .format(a) 当前输入需要格式化分格式
 * 使用格式方法:   myMoment("20210101").format("YYYY-MM-DD");
 * 支持格式:"YYYY-MM-DD","YYYY/MM/DD","MM-DD","MM/DD","YY-MM","YY/MM","HH:MM:SS","H:MM:SS"
 */

const Moment: any = () => { };
Moment.prototype = {
    moment(date: any) {
        let dateStr = `${date}`;
        if (dateStr.length < 8) {
            dateStr = dateStr.padStart(8, '0');
        }
        this.date1 = `${dateStr}`;
        return this;
    },
    format(a: any) {
        a = a.toUpperCase();
        const setData = this.date1;
        let yyyy = '';
        let mm = '';
        let dd = '';
        let yy = '';
        let HH = '';
        let MM = '';
        let SS = '';
        if (setData.length == 8) {
            yyyy = setData.substr(0, 4);
            yy = setData.substr(2, 4);
            mm = setData.substr(4, 2);
            dd = setData.substr(6, 2);
            HH = setData.substr(0, 2);
            MM = setData.substr(2, 2);
            SS = setData.substr(4, 2);
        }
        if (setData.length == 4) {
            mm = setData.substr(4, 2);
            dd = setData.substr(6, 2);
        }
        if (setData.length == 6) {
            HH = setData.substr(2, 2);
            MM = setData.substr(4, 2);
            SS = setData.substr(6, 2);
        }
        const yyyymmmdd = [yyyy, mm, dd];
        const mmmdd = [mm, dd];
        const yymm = [yy, mm];
        const hhmmss = [HH, MM, SS];
        const hhmmssss = [HH, MM, SS, dd];
        if (a == 'YYYY-MM-DD') return yyyymmmdd.join('-');
        if (a == 'YYYY/MM/DD') return yyyymmmdd.join('/');
        if (a == 'MM-DD') return mmmdd.join('-');
        if (a == 'MM/DD') return mmmdd.join('/');
        if (a == 'YY-MM') return yymm.join('-');
        if (a == 'YY/MM') return yymm.join('/');
        if (a == 'HH:MM:SS') return hhmmss.join(':');
        if (a == 'H:MM:SS') return hhmmss.join(':');
        if (a == 'H:MM:SS:SS') return hhmmssss.join(':');
        return this.date1;
    },
};
function myMoment(aa: any) {
    const cc: any = new Moment();
    cc.moment(aa);
    return cc;
}

// 获取日期时间转换
function getFormatDate(time: any, date: any, date1: any) {
    let res = '';
    let str = '';
    let tmp = '';
    const timeStr = time.toString().trim();
    if (date !== 0) {
        tmp = `00000000${timeStr}`;
        tmp = tmp.substring(tmp.length - 8, tmp.length);
        str = tmp.substring(0, 2).concat(':').concat(tmp.substring(2, 4)).concat(':')
            .concat(tmp.substring(4, 6));
    }
    let Str = '';
    if (date) {
        const dateStr = date.toString().trim();
        const month1 = Number(date1.substring(0, 2));
        const month2 = Number(dateStr.substring(4, 6));
        if (month1 - month2 === 11) {
            const year = `${Number(dateStr.substring(0, 4)) - 1}`;
            Str = year.concat('-').concat(date1.substring(0, 2)).concat('-').concat(date1.substring(2, 4));
        } else {
            Str = dateStr.substring(0, 4).concat('-').concat(date1.substring(0, 2)).concat('-')
                .concat(date1.substring(2, 4));
        }

        res = `${Str} ${str}`;
    }
    return res;
}

/**
*  发送静态短信
*  msgContent: 传入的动态短信模板内容
*  that: vue实例
* * */
function sendMessage(msgContent: String, that: any) {
    const defaultParams = JSON.parse(JSON.stringify(that.defaultParams));
    const { sysHead } = defaultParams;
    const { appHead } = defaultParams.body;
    const params = {
        bankNum: getTokenHsbankNo('HsbankNo'), // 银行号
        bnknbr: getTokenHsbankNo('HsbankNo'), // 银行号
        busiName: sysHead.busiName, // 当前菜单名称
        busiType: sysHead.busiType, // 业务类型
        chnlNo: sysHead.chnlNo, // 渠道号
        loginId: sysHead.loginID, // 登录用户id
        sessionID: sysHead.sessionID,
        brnNo: appHead.brnNo, // 网点代号
        opeNo: appHead.opeNo, // 操作员号
        source: appHead.source, // 交易来源
        tranCode: '6001', // 交易号

        tempContent: msgContent, // 短信内容
        // tempId: that.formDataMessage.id, // 短信模板
        acctname1: that.cardInfo_3004.NAME, // 客户姓名
        custid: that.cardInfo_3004.CUSTID, // 证件号
        keytype: that.cardInfo_3004.KEYTYPE, // 证件类型
        cardno: that.cardInfo_3004.CARDNO.trim(), // 卡号
        mobilephone: that.customerInfo_3002.MOBILEPHONE, // 手机号
    };
    that.$post.Template.sendMsgAndSave(params).then((res: any) => {
        that.sendLoading = false;
        if (res.status === 200 && res.data.success) {
            that.$alert('短信发送成功', '提示').then(() => { });
        } else {
            that.$alert('短信发送失败', '提示', { type: 'error' });
        }
    });
}

// 补卡费用计算
function componentCost(val: String, that: any) {
    // 首先拿到当前卡片的卡种 
    // 然后获取到当前卡片的收费类型是普通还是加急 免费不要钱
    // console.log('this.PRODUCT', that.PRODUCT);
    let commonType = '', UrgentType = '';
    that.cardtype.filter((item: any) => {
        // 0 是其他类型的卡种 
        if (item.code === '0') {
            // console.log('item', item);
            commonType = item.label;
            UrgentType = item.remark || '20';
            return;
        }
    })
    // console.log('commonType', commonType);
    // console.log('UrgentType', UrgentType);
    switch (val) {
        // 免费
        case '0':
            that.COST_value = 0;
            break;
        // 普通 其他的20元 匹配上的都是0元
        case '1':
            if (that.cardtype.some((item: any) => item.code === that.PRODUCT)) {
                that.COST_value = 0;
            } else {
                // 其他的20元
                that.COST_value = UrgentType;
            }
            break;
        // 加急 其他的就是45元 匹配上了 在取值
        case '2':
            // 这是其他 45元
            if (!that.cardtype.some((item: any) => item.code === that.PRODUCT)) {
                that.COST_value = commonType;
            } else {
                that.cardtype.filter((item: any) => {
                    if (item.code === that.PRODUCT) {
                        that.COST_value = item.label;
                        return;
                    }
                })
            }
            break;
        default:
            that.COST_value = 0;
            break;
    }
}
/**
*  更新3096IC卡交易明细查询
*  cardNumber:  卡号
*  that: vue实例
* * */
// 3096IC卡交易明细查询
async function
    setICCardInfo(cardNumber: any, that: any,) {
    const defaultParams = JSON.parse(JSON.stringify(that.defaultParams));
    let params = {
        OPTION: 'A',
        CARDNBR: cardNumber, // 卡号
        TRANTYPE: 'A', // 分期类型
        OPERCODE: '0',//操作代码，0-全部返回，1-可提前还款的分期交易，2-可撤销的分期交易
        PINFLAG: that.pinFlag, // 是否检查密码标志 0-不检查
        STDATE: moment().subtract(5, 'year').format('YYYYMMDD'), // 开始日期 , // 起始日期 YYYYMMDD
        ENDDTE: moment().format('YYYYMMDD'), // 终止日期
        RTNIND: '', // 翻页标志 首次传空， 翻页传1
        CENDT: '', // 首次查询时送空， 下翻页查询时上送上次查询结果的最后一条记录返回的交易传输时间
        TRCNBR: '', // 首次查询时送空， 下翻页查询时上送上次查询结果的最后一条记录返回的系统跟踪号
        ACQNO: '',// 首次查询时送空， 下翻页查询时上送上次查询结果的最后一条记录返回的代理机构标识码
        FORNO: '',// 首次查询时送空， 下翻页查询时上送上次查询结果的最后一条记录返回的发送机构标识码
        TXNDATE: '',// 首次查询时送空， 下翻页查询时上送上次查询结果的最后一条记录返回的交易日期
        OPDATE: '',// 首次查询时送空， 下翻页查询时上送上次查询结果的最后一条记录返回的登记日期
        OPTIME: '',// 首次查询时送空， 下翻页查询时上
    };
    defaultParams.body.appBody = Object.assign(that.defaultParams.body.appBody, params);
    defaultParams.body.appHead.tranCode = '3096';// 修改交易号
    await that.$post.common.transPort(defaultParams).then((res: any) => {
        if (res.status === 200) { // 请求成功
            const cardlossofs = JSON.parse(res.data.jsonRes);
            //if (cardlossofs.sysHead.rspCd == '000000') { // 交易成功
            // console.log(cardlossofs, 'cardlossofs_3096ICC');
            // 取芯片卡可用余额
            that.BALANCE_value = cardlossofs.body.appBody.BALANCE || '0';

            //} else {
            // const ErrorMessage = `错误码：${cardlossofs.sysHead.rspCd} ` + `错误信息：${cardlossofs.sysHead.rspMsg}`;
            // that.$alert(ErrorMessage, cardlossofs.sysHead.busiName, { customClass: 'error', type: 'error' });
            // that.BALANCE_value = '0';
            //}
        }
    });
}

/**
*  更新3134ETC签约关系查询交易接口
*  cardNumber:  卡号 
*  that: vue实例
*  RTNIND_value 翻页标志
*  ETCSTATUS_value 是否绑定etc
* * */
// 3134ETC签约关系查询交易接口
async function setETCCardInfo(cardNumber: any, that: any) {
    const defaultParams = JSON.parse(JSON.stringify(that.defaultParams));
    let params = {
        OPTION: '1',//操作选项
        CARDNBR: cardNumber,//
        INQSEL: '1',//查询方式
        RTNIND: that.RTNIND_value,
        RTNETCARD: '',//翻页ETC卡号
    };
    defaultParams.body.appBody = Object.assign(that.defaultParams.body.appBody, params);
    defaultParams.body.appHead.tranCode = '3134';// 修改交易号
    await that.$post.common.transPort(defaultParams).then((res: any) => {
        if (res.status === 200) { // 请求成功
            const cardInfo = JSON.parse(res.data.jsonRes);
            // that.ETCCardInfo.push(...cardInfo.body.appBody.dataList);
            // console.log(cardInfo, 'cardInfo_3134ETC');
            if (cardInfo.sysHead.rspCd == '000000') { // 交易成功
                let RTNIND_val = (cardInfo.body.appBody.RTNIND + '').trim();
                if (RTNIND_val === '1') {
                    that.RTNIND_value = RTNIND_val;
                    setETCCardInfo(cardNumber, that);
                }
                if (cardInfo.body.appBody.dataList.length > 0) {
                    that.ETCSTATUS_value = true;
                }
            } else {
                // const ErrorMessage = `错误码：${cardInfo.sysHead.rspCd} ` + `错误信息：${cardInfo.sysHead.rspMsg}`;
                // that.$alert(ErrorMessage, cardInfo.sysHead.busiName, { customClass: 'error', type: 'error' });
                that.ETCSTATUS_value = false;
            }
        }
        that.pageLoading = false;
    });
}
// 3001信用卡账户查询 CardnbrNumOption 字段走3004 会更新
async function getNewCardAccount3001(cardNumber: any, that: any,) {
    const defaultParamInfos = JSON.parse(JSON.stringify(that.defaultParams));
    defaultParamInfos.body.appHead.tranCode = '3001';// 修改交易号
    defaultParamInfos.body.appBody = {
        PINFLAG: that.pinFlag,
        PIN: '',
        CARDNO: cardNumber,// 卡号
    };
    await that.$post.common.transPort(defaultParamInfos).then((res: any) => {
        if (res.status === 200) { // 请求成功
            const cardlossofs = JSON.parse(res.data.jsonRes);
            // console.log(cardlossofs, '3001信用卡账户查询');
            if (cardlossofs.sysHead.rspCd == '000000') { // 交易成功
                // 更新 vuex 缓存 卡账户信息
                // that.cardAccountInfos_3001 =  cardlossofs.body.appBody;
                that.newCardAccountInfo_3001 = cardlossofs.body.appBody;

            } else {
                let ErrorMessage = '错误码：' + cardlossofs.sysHead.rspCd + ' ' + '错误信息：' + cardlossofs.sysHead.rspMsg;
                that.$alert(ErrorMessage, cardlossofs.sysHead.busiName, {
                    customClass: 'error'
                })
            }
        }
    });
}

// 3001信用卡账户查询 CardnbrNumOption 字段走3004 会更新
async function updateCardAccount3001(cardNumber: any, that: any,) {
    const defaultParamInfos = JSON.parse(JSON.stringify(that.defaultParams));
    defaultParamInfos.body.appHead.tranCode = '3001';// 修改交易号
    defaultParamInfos.body.appBody = {
        PINFLAG: that.pinFlag,
        PIN: '',
        CARDNO: cardNumber,// 卡号
    };
    await that.$post.common.transPort(defaultParamInfos).then((res: any) => {
        if (res.status === 200) { // 请求成功
            const cardlossofs = JSON.parse(res.data.jsonRes);
            // console.log(cardlossofs, '3001信用卡账户查询');
            if (cardlossofs.sysHead.rspCd == '000000') { // 交易成功
                // 更新 vuex 缓存 卡账户信息
                // that.cardAccountInfos_3001 =  cardlossofs.body.appBody;
                //that.newCardAccountInfo_3001 = cardlossofs.body.appBody;
                that.$store.commit('common/UPDATE_CARD_ACCOUNT_INFO', cardlossofs.body.appBody);

            } else {
                let ErrorMessage = '错误码：' + cardlossofs.sysHead.rspCd + ' ' + '错误信息：' + cardlossofs.sysHead.rspMsg;
                that.$alert(ErrorMessage, cardlossofs.sysHead.busiName, {
                    customClass: 'error'
                })
            }
        }
    });
}
/**
*  更新3004 交易
*  cardNumber:  卡号
*  that: vue实例
* * */
async function updateDeal3004(cardNumber: string, that: any) {
    const defaultParamInfo = JSON.parse(JSON.stringify(that.defaultParams));
    defaultParamInfo.body.appHead.tranCode = '3004';// 修改交易号
    defaultParamInfo.body.appBody = {
        CARDNO: cardNumber,
        CARDNBR: cardNumber,
        PINFLAG: '',
    }
    await that.$post.common.transPort(defaultParamInfo).then((res: any) => {
        const IDNumData = JSON.parse(res.data.jsonRes);
        if (res.status === 200) { // 请求成功
            // console.log(IDNumData, '3004_卡资料信息');
            if (IDNumData.sysHead.rspCd == '000000') { // 交易成功
                // 更新3004 不用 判断是否有新卡 传进来的卡号就是 新卡
                that.nowcardstat = IDNumData.body.appBody.CARDSTAT;
                that.$store.commit('common/UPDATE_CARD_INFO_ONE', IDNumData.body.appBody);
                // console.log('数据修改完成！');
            } else {
                // const ErrorMessage = `错误码：${IDNumData.sysHead.rspCd} ` + `错误信息：${IDNumData.sysHead.rspMsg}`;
                // that.$alert(ErrorMessage, IDNumData.sysHead.busiName, '提示', {
                //     customClass: 'error', type: 'error',
                // });
            }
        }
    });
}
/**
*  跑3004 交易 不更新缓存里的3004数据
*  cardNumber:  卡号
*  that: vue实例
* * */
async function getCardInfo3004(cardNumber: string, that: any) {
    const defaultParamInfo = JSON.parse(JSON.stringify(that.defaultParams));
    defaultParamInfo.body.appHead.tranCode = '3004';// 修改交易号
    defaultParamInfo.body.appBody.CARDNO = cardNumber;
    defaultParamInfo.body.appBody.CARDNBR = cardNumber;
    defaultParamInfo.body.appBody.PINFLAG = '';
    await that.$post.common.transPort(defaultParamInfo).then((res: any) => {
        const IDNumData = JSON.parse(res.data.jsonRes);
        if (res.status === 200) { // 请求成功
            // console.log(IDNumData, '3004_卡资料信息');
            if (IDNumData.sysHead.rspCd == '000000') { // 交易成功
                // 更新3004 不用 判断是否有新卡 传进来的卡号就是 新卡
                that.newCardInfo_3004 = IDNumData.body.appBody;
                // that.$store.commit('common/UPDATE_CARD_INFO_ONE', IDNumData.body.appBody);
                // console.log('数据修改完成！');
            } else {
                // const ErrorMessage = `错误码：${IDNumData.sysHead.rspCd} ` + `错误信息：${IDNumData.sysHead.rspMsg}`;
                // that.$alert(ErrorMessage, IDNumData.sysHead.busiName, '提示', {
                //     customClass: 'error', type: 'error',
                // });
            }
        }
    });
}
/**
*   翻译银联数据近24个月还款情况
*  cupaym24: 银联数据近24个月还款情况
*  卡系统3054接口返回CUPAYM24的字符串每个字母代表当月还款情况，顺序是从左到右为由近到远
*   0-9表示没有逾期，翻译为N
*   A-对上期账单余额还款未达系统定义的“最低还款”要求，翻译为1
*   B-表示逾期31-60天；翻译为2
*   C-表示逾期61-90天；翻译为3
*   D-逾期90-119天；翻译为4
*   E-表示逾期91-120天；翻译为5
*   F-表示逾期121-150天；翻译为6
*   G-表示逾期151-180天；翻译为7
*   H到Q均表示逾期7以上，统一翻译为7
*   星号表示没有任何账单记录，不做翻译
*   newcupaym24:    翻译后的24个月逾期情况，顺序跟3054接口返回字符串顺序相反
* * */
async function getNewCUPAYM24(cupaym24: string) {
    let result = '';
    const rgx = /^\d+$/;
    if (!isNull(cupaym24)) {
        if (cupaym24.trim() != '') {
            for (let i = 0; i < cupaym24.length; i++) {
                let item = cupaym24.substring(i, i + 1);
                if (item === '*') { //星号不翻译
                    result = item + result;
                } else if (item === '0') { //星号不翻译
                    result = '*' + result;
                } else {
                    if (rgx.test(item)) {//数字翻译为N-表示没有逾期
                        result = 'N' + result;
                    } else {
                        if (item + '' === 'A') {
                            result = '1' + result;
                        } else if (item + '' === 'B') {
                            result = '2' + result;
                        } else if (item + '' === 'C') {
                            result = '3' + result;
                        } else if (item + '' === 'D') {
                            result = '4' + result;
                        } else if (item + '' === 'E') {
                            result = '5' + result;
                        } else if (item + '' === 'F') {
                            result = '6' + result;
                        } else {
                            result = '7' + result;
                        }
                    }
                }
            }
        }
    }
    return result;
}
/**
*  更新3074 交易 改为 3601
*  cardNumber:  卡号
*  custid 证件号
*  that: vue实例
* * */
async function updateDeal3601(cardNumber: string, keytype: string, custid: string, that: any) {
    let last_card_id = '';
    const defaultParamInfo = JSON.parse(JSON.stringify(that.defaultParams));
    defaultParamInfo.body.appHead.tranCode = '3601';// 修改交易号
    defaultParamInfo.body.appBody = {
        CARDNO: cardNumber,
        CARDNBR: cardNumber,
        KEYTYPE: keytype,//证件类型
        CUSTID: custid,//证件号码
        PIN: '',//密码
        PINFLAG: '0',//是否检查密码标志
        RTNIND: RTNIND_value,//// RTN-IND 翻页标志
        INSFLAG: '1',//查询方式
    };
    // .CARDNO = cardNumber;
    // defaultParamInfo.body.appBody.CARDNBR = cardNumber;
    // defaultParamInfo.body.appBody.CUSTID = custid; // 证件号码
    // defaultParamInfo.body.appBody.KEYTYPE = '01';
    // defaultParamInfo.body.appBody.PIN = ''; // 密码
    // defaultParamInfo.body.appBody.PINFLAG = '0'; // 是否检查密码标志
    // defaultParamInfo.body.appBody.RTNIND = RTNIND_value; // RTN-IND 翻页标志
    // defaultParamInfo.body.appBody.INSFLAG = '1',

    await that.$post.common.transPort(defaultParamInfo).then((res: any) => {
        const cardData = JSON.parse(res.data.jsonRes);
        if (res.status === 200) { // 请求成功
            // console.log(cardData, '3601_卡列表');
            if (cardData.sysHead.rspCd == '000000') { // 交易成功
                RTNIND_value = cardData.body.appBody.RTNIND;
                cardList.push(...cardData.body.appBody.dataList);
                // 更新vuex里的卡信息
                if (RTNIND_value === '1') {
                    last_card_id = (`${cardData.body.appBody.dataList[4].CARDNBR}`).trim();
                    updateDeal3601(last_card_id, keytype, custid, that);
                } else {
                    RTNIND_value = '';
                    last_card_id = '';
                    // 更新vuex里的卡信息
                    // console.log(cardList, 'cardList_11111111');

                    that.$store.commit('common/UPDATE_CARD_LIST', cardList);
                    cardList = [];
                }
            } else {
                that.$alert(cardData.sysHead.rspMsg, '提示');
            }
        }
    });
}
/**
*   3077分期付款交易明细查询
*  cardNumber:  卡号
*  OPTValue  查询方式
*  custid 证件号
*  keytypeval 证件类型
*  accountType 账户类型
*  that: vue实例
* * */
async function getNewFQFK3077(cardNumber: string = '', that: any, OPTValue: string = '1', custid: string = '', keytypeval: string = '', accountType: string = '',) {
    const appBody = {
        CARDNBR: cardNumber, // 卡号
        // 空或Z：全部  A：灵活分期 C：信用计划分期 B：余额转移 H：银联POS分期 L：大额分期 M：邮购分期  P：自行POS分期 S：深圳银联POS分期 Y：余额/账单分期 D：自动分期
        MPTYPE: '', // 分期付款类型
        OPERCODE: 0, // 操作代码  0全部返回  1可提前还款的分期交易    2可撤销的分期交易
        OPT: OPTValue, // 查询方式 1-用卡号查询 2-用证件号码查询
        CUSTNBR: custid,//证件号
        KEYTYPE: keytypeval,//证件类型
        CATE: accountType, // 账户类别 查询方式为2时，必填
        PINFLAG: that.pinFlag, // 是否检查密码标志
        BEGDAY: "20000101", // 起始日期
        ENDDAY: moment(new Date()).format('YYYYMMDD'), // 结束日期 两个月 内的
        RTNIND: that.RtnindFlag,// 翻页标志 首次传空， 翻页传1
        NEXTDAY: that.NEXTDAY_3077,// 首次查询时送查询起始日期， 下翻页查询时上送上次查询结果的最后一条记录返回的分期付款交易日期
        NEXTMPNO: that.NEXTMPNO_3077,// 首次查询时送起始序号，默认为0 下翻页查询时上送上次查询结果的最后一条记录返回的交易序号
    };
    const defaultParams = JSON.parse(JSON.stringify(that.defaultParams));
    defaultParams.body.appHead.tranCode = '3077';
    defaultParams.body.appBody = appBody;
    // 3077交易
    that.$post.common.transPort(defaultParams).then((res: any) => {
        if (res.status === 200) {
            const result = JSON.parse(res.data.jsonRes);
            if (result.sysHead.rspCd === '000000') {
                // console.log('result_3077', result);
                // console.log("OPTValue", OPTValue);
                if (OPTValue === '1') {
                    that.newInstallmentInfo_3077.push(...result.body.appBody.dataList);
                } else {
                    that.newAccountInstallmentInfo_3077.push(...result.body.appBody.dataList);
                }

                if (result.body.appBody.RTNIND === '1') {
                    that.NEXTDAY_3077 = result.body.appBody.dataList[result.body.appBody.dataList.length - 1].BEGYM;
                    that.NEXTMPNO_3077 = result.body.appBody.dataList[result.body.appBody.dataList.length - 1].MPNO;
                    // 修改翻页标志 
                    that.RtnindFlag = result.body.appBody.RTNIND
                    getNewFQFK3077(cardNumber, that, OPTValue, custid, keytypeval, accountType);
                } else {
                    // console.log('that.newInstallmentInfo_3077', that.newInstallmentInfo_3077);
                    // console.log('that.newAccountInstallmentInfo_3077', that.newAccountInstallmentInfo_3077);
                }
            } else {
                // const ErrorMessage = `错误码：${result.sysHead.rspCd} ` + `错误信息：${result.sysHead.rspMsg}`;
                // that.$alert(ErrorMessage, result.sysHead.busiName, '提示', {
                //     customClass: 'error', type: 'error',
                // });
            }
        }
    });
}
// 循环遍历 业务菜单的Child 级 菜单
function getBusinessMenuId(menuPath: String, businessMenu: any) {
    let menuId: String = '';
    for (let i = 0; i < businessMenu.length; i++) {
        if (businessMenu[i].child.length > 0) {
            let somevalue = businessMenu[i].child.some((item: any) => {
                if (item.routerName === menuPath) {
                    menuId = item.id;
                    return true;
                }
            })
            if (somevalue) {
                return menuId
            }

        }
    }
}

function random(n: number, m: number) {
    return Math.floor(Math.random() * (n - m) + m);
}

export {
    isNull,
    isBoolean,
    isString,
    isNumber,
    isEmpty,
    base64Encode,
    MobileNum,
    closePage,
    trimString,
    reolaceString,
    strZeroFill,
    formatNumber,
    ForDight,
    itoStr,
    getDictSelectList,
    getDictMappingValue,
    getDictValue,
    getInstalmentList,
    getAccountTypeName,
    dealTempContent,
    getDictDetailPage,
    myMoment,
    sendMessage,
    getAllInstalmentList,
    getNewCardAccount3001,
    updateCardAccount3001,
    updateDeal3004,
    getCardInfo3004,
    updateDeal3601,
    getNewFQFK3077,
    getFormatDate,
    getDictFromBankNum,
    getALLCupdAndIBankDict,
    getDictSelectListOneValue,
    checkUrgeRules,
    checkApplyRules,
    componentCost,
    setETCCardInfo,
    setICCardInfo,
    getNewCUPAYM24,
    getBusinessMenuId,
    random,
};
